5.03. Типы данных в Java

ОБЯЗАТЕЛЬНОДЛЯ НОВИЧКОВНЕ ДЛЯ НОВИЧКОВВ РАЗРАБОТКЕ

Разработчику Архитектору

Типы данных в Java

Тип данных — фундаментальное понятие, определяющее множество допустимых значений, операций над ними и способ их представления в памяти. В языке Java тип переменной фиксируется на этапе компиляции, что делает его статически типизированным. Это означает, что компилятор проверяет корректность всех операций с данными до запуска программы, предотвращая множество потенциальных ошибок времени выполнения. Нарушение типовой дисциплины (например, попытка вызвать метод у переменной числового типа) приведёт к ошибке компиляции и остановит сборку.

Система типов Java разделяет все типы на две большие категории: примитивные и ссылочные. Примитивные типы реализованы на уровне виртуальной машины Java (JVM) и имеют фиксированный размер, не зависящий от платформы. Ссылочные типы реализуются как объекты, размещаемые в куче (heap), и манипулируются через ссылки — специальные дескрипторы, указывающие на область памяти, где хранится объект. Разделение на примитивы и ссылки — отражение архитектурных решений JVM и компромисса между производительностью (примитивы) и выразительной мощью (объекты).

Примитивные типы данных

В Java существует ровно восемь примитивных типов. Ни один из них не является классом, ни один не наследует от java.lang.Object, и ни к одному из них нельзя применить оператор new. Все примитивные значения хранятся непосредственно в памяти, в том месте, где размещена переменная: в стеке — если это локальная переменная метода, или в теле объекта — если это поле класса. Такая организация обеспечивает предсказуемое время доступа и минимизирует накладные расходы, что критично для вычислительно интенсивных задач.

Целочисленные типы

Целочисленные примитивы предназначены для представления значений из дискретного множества целых чисел. Все они знаковые (то есть могут хранить как положительные, так и отрицательные числа), за исключением специального беззнакового типа char, который рассматривается отдельно. Внутренне целые числа хранятся в формате дополнительный код (two’s complement), что обеспечивает единообразную обработку арифметических операций и упрощает реализацию процессорных инструкций.

Тип	Размер (байт)	Диапазон значений	Типичное применение
byte	1	от −128 до +127	Экономия памяти при работе с большими объёмами числовых данных (например, байтовые потоки, изображения в сыром виде, сетевые пакеты).
short	2	от −32 768 до +32 767	Случаи, когда int избыточен по диапазону и память критична. Редко используется в современных приложениях, так как экономия незначительна, а стоимость ошибки из-за переполнения выше.
int	4	от −2 147 483 648 до +2 147 483 647	Стандартный тип для всех целочисленных вычислений. Литералы без суффикса (42, −1000) интерпретируются как int. Используется в циклах, индексации массивов, идентификаторах, перечислениях.
long	8	от −9 223 372 036 854 775 808 до +9 223 372 036 854 775 807	Там, где диапазона int недостаточно: временные метки в миллисекундах (см. System.currentTimeMillis()), идентификаторы сущностей в распределённых системах, финансовые операции с большими суммами. Литералы требуют суффикса L или l (предпочтительно L, так как l легко спутать с цифрой 1). Например: 9_223_372_036_854_775_807L.

Выбор между int и long — вопрос не столько производительности (на большинстве современных архитектур разница минимальна), сколько семантики и будущей расширяемости. Если есть хоть малая вероятность выхода за пределы 32-битного диапазона — безопаснее сразу использовать long. Переполнение целочисленного типа в Java не вызывает исключений — оно происходит «тихо», по модулю 2ⁿ, где n — разрядность типа. Например, прибавление единицы к максимальному int даёт минимальное отрицательное значение. Для критичных случаев следует использовать методы из класса Math, такие как Math.addExact(), которые выбрасывают ArithmeticException при переполнении.

Вещественные (с плавающей точкой) типы

Вещественные типы предназначены для приближённого представления действительных чисел. Они реализуют стандарт IEEE 754 и, как следствие, подвержены ограничениям, свойственным двоичной арифметике с плавающей точкой: невозможность точно представить многие десятичные дроби (например, 0,1), накопление погрешности при последовательных операциях, особые значения — положительная и отрицательная бесконечность, не число (NaN).

Тип	Размер (байт)	Мантисса (бит)	Экспонента (бит)	Типичное применение
float	4	23	8	Вычисления, где важна память и скорость, а погрешность допустима: графика (OpenGL, обработка изображений), физические симуляции реального времени. Литералы должны иметь суффикс F или f: 3.14159265f.
double	8	52	11	Стандартный тип для всех вещественных вычислений в бизнес-логике, научных расчётах, финансовой аналитике (но не бухгалтерии!). Литералы без суффикса (3.14, 1e−5) интерпретируются как double. Обеспечивает примерно 15–17 значащих десятичных цифр точности.

Важно подчеркнуть: никогда не следует использовать float или double для точных денежных расчётов. Из-за двоичного представления десятичные суммы вроде 0,10 рублей или 0,01 доллара хранятся с погрешностью, что недопустимо в финансовых системах. Для таких случаев в Java предусмотрен класс java.math.BigDecimal, обеспечивающий произвольную точность и строгий контроль округлений.

Сравнение значений типа float и double требует осторожности. Прямое равенство (==) часто даёт неожиданный результат из-за погрешности. Рекомендуется сравнивать с заданной точностью («эпсилон») или использовать метод Double.compare() / Float.compare() для учёта специальных значений.

Символьный тип char

Тип char занимает ровно 2 байта и предназначен для представления одного символа в кодировке UTF-16. В силу этого он способен охватить весь базовый многоязычный диапазон Unicode (BMP, от U+0000 до U+FFFF), но не все символы из дополнительных плоскостей (например, эмодзи), которые требуют суррогатной пары — двух значений типа char. В современных приложениях, сталкивающихся с расширенным Unicode, целесообразно работать со строками (String) целиком и использовать методы, учитывающие суррогатные пары, например String.codePointAt().

Литералы char записываются в одинарных кавычках: 'A', 'я', '\n' (управляющий символ), '\u0041' (Unicode escape). Несмотря на то, что char хранится как 16-битное беззнаковое целое, в арифметических операциях он ведёт себя как число (например, 'A' + 1 даёт 'B'), но семантически его следует рассматривать именно как символ, а не как число.

---

Булев тип boolean

Тип boolean — единственный примитив, не имеющий числового представления. Он принимает ровно два значения: true и false. В отличие от некоторых языков (например, C), в Java не существует неявного преобразования между boolean и целочисленными типами: выражение if (1) не скомпилируется. Это сознательное ограничение, направленное на повышение надёжности — условие должно быть логическим по своей природе, а не зависеть от побочных свойств чисел.

Размер типа boolean в байтах не определён спецификацией языка и остаётся на усмотрение реализации JVM. В стеке или регистрах процессора значение может занимать полный машинный слово (например, 4 или 8 байт), но в массивах (boolean[]) многие JVM упаковывают элементы по одному биту на значение, экономя память. Программисту эта деталь не должна быть видна — важно лишь то, что переменная boolean гарантирует хранение одного из двух логических состояний.

Операции над булевыми значениями включают:

• логическое И (&&) и ИЛИ (||) — короткозамкнутые (short-circuit), то есть правый операнд не вычисляется, если результат определён левым;
• побитовое И (&) и ИЛИ (|) — вычисляют оба операнда, применяются редко, чаще в битовой арифметике с масками;
• исключающее ИЛИ (^);
• отрицание (!).

Результат вычисления любого логического выражения (включая сравнения ==, !=, <, >, <=, >=) имеет тип boolean. Этот тип лежит в основе условных конструкций (if, while, for), обеспечивая управление потоком выполнения на основе чётко определённых предикатов.

Важно отметить, что boolean не имеет обёртки с методами, аналогичными числовым классам (Integer, Double), но существует класс java.lang.Boolean, предоставляющий полезные статические методы: parseBoolean(), valueOf(), а также константы TRUE и FALSE. При автоматической упаковке (Boolean b = true) создаётся объект, ссылающийся на одну из этих разделяемых констант, что экономит память.

---

Ссылочные типы

Всё, что не является одним из восьми примитивов, относится к ссылочным типам. Это включает:

• классы (встроенные, такие как String, ArrayList, и пользовательские);
• интерфейсы;
• перечисления (enum);
• массивы любого типа (в том числе массивы примитивов);
• аннотации.

Переменная ссылочного типа не содержит самого объекта, а хранит ссылку на него — абстрактный дескриптор, позволяющий JVM найти объект в куче. Ссылка может принимать специальное значение null, означающее отсутствие объекта. Это ключевое отличие от примитивов: переменная примитивного типа всегда содержит некое значение (инициализированное явно или по умолчанию: 0, 0.0, false, '\u0000'), тогда как ссылка может указывать «никуда».

Размер ссылки фиксирован на данной JVM (обычно 4 или 8 байт, в зависимости от разрядности и настроек сжатия указателей), но размер объекта, на который она указывает, динамичен и определяется его классом: сумма размеров всех полей (с учётом выравнивания), плюс заголовок объекта (metadata, включающий ссылку на класс, флаги синхронизации и т.п.).

Передача аргументов в методы для ссылочных типов происходит по значению ссылки. Это часто ошибочно называют «передачей по ссылке», но технически это не так: копируется не объект, и не ссылка как таковая, а значение, содержащее адрес объекта. В результате метод может изменять состояние объекта (через полученную ссылку), но не может изменить саму ссылку в вызывающем коде (например, присвоить ей null или новый объект — такие изменения останутся локальными).

---

Строка: java.lang.String

Класс String заслуживает отдельного рассмотрения из-за повсеместного использования и благодаря своей уникальной семантике — неизменяемости (immutability). После создания объект String не может быть изменён: все его методы (substring(), toUpperCase(), replace()) возвращают новый объект строки, оставляя исходный нетронутым. Это обеспечивает:

• потокобезопасность: один и тот же String можно безопасно использовать во многих потоках без синхронизации;
• кэширование хэш-кода (поле hash вычисляется один раз и сохраняется);
• эффективное использование пула строк (string pool).

Пул строк — область памяти в куче (с Java 7+ — в куче, а не в PermGen), где JVM хранит интернированные строковые литералы и строки, явно помещённые туда через метод intern(). При создании литерала (String s = "hello";) JVM проверяет пул: если такая строка уже есть — возвращается ссылка на неё; если нет — строка создаётся и добавляется в пул. Это позволяет экономить память и ускорять сравнение через == (хотя для содержательного сравнения всегда следует использовать equals()).

Важно различать два способа создания строки:

String a = "hello";                 // литерал — интернируется
String b = new String("hello");     // явный вызов конструктора — создаёт *новый* объект вне пула

Здесь a == b будет false, хотя a.equals(b) — true.

Класс String предоставляет богатый API для форматирования, поиска, сравнения, преобразования регистра. Метод String.format() — это Java-аналог printf, поддерживающий сложные шаблоны с позиционными спецификаторами (%1$s, %2$d) и повторным использованием (%<). Для частых или тяжеловесных операций конкатенации (особенно в циклах) следует использовать StringBuilder (для однопоточных сценариев) или StringBuffer (потокобезопасный, но медленнее), так как оператор + для строк компилируется в цепочку созданий StringBuilder, что может привести к избыточным аллокациям.

---

Массивы

Массив в Java — ссылочный тип фиксированной длины, хранящий элементы одного и того же типа (примитивного или ссылочного) в непрерывном блоке памяти. Длина массива определяется при создании и не может быть изменена — это фундаментальное ограничение. Для динамических коллекций используются классы из java.util (ArrayList, LinkedList и др.).

Объявление массива синтаксически допускает размещение квадратных скобок как после типа (int[] arr), так и после имени (int arr[]), но первый вариант предпочтителен: он подчёркивает, что «массив целых» — это тип int[], а не свойство переменной.

При создании массива (через new) все его элементы инициализируются значениями по умолчанию:

• 0 для числовых примитивов;
• false для boolean;
• '\u0000' для char;
• null для ссылочных типов.

Массивы сами являются объектами и наследуют от java.lang.Object. У каждого массива есть публичное поле length, содержащее его длину (в отличие от метода size() у коллекций). Массивы поддерживают многомерность, но в Java это реализуется как массив массивов (jagged arrays), а не как единый блок памяти. Например, int[][] matrix = new int[3][] создаёт массив из трёх ссылок, каждая из которых может указывать на массив разной длины.

Попытка доступа к элементу за пределами [0, length) вызывает исключение ArrayIndexOutOfBoundsException — типичная ошибка при некорректной индексации.

---

Объекты и методы

Всякий объект в Java — экземпляр некоторого класса. Даже массив — экземпляр специального синтетического класса, сгенерированного JVM. Все классы неявно или явно наследуют от java.lang.Object, что даёт каждому объекту набор базовых методов: equals(), hashCode(), toString(), getClass(), clone(), finalize().

Корректная реализация equals() и hashCode() — критически важна для работы коллекций на основе хэширования (HashMap, HashSet). Если два объекта равны по equals(), их hashCode() должны совпадать. Некорректная реализация нарушает инварианты коллекций и приводит к трудноуловимым ошибкам (например, объект не находится в HashMap, несмотря на «равенство» ключей).

Методы в Java всегда принадлежат классу — отдельно стоящих функций не существует. Метод определяет поведение объекта или класса (статический метод). Он характеризуется:

• именем;
• списком параметров (включая их типы и имена);
• возвращаемым типом (void, если ничего не возвращается);
• модификаторами доступа (public, private, protected, package-private);
• сигнатурой (комбинация имени и типов параметров — определяет перегрузку);
• телом (реализация).

Современный стиль Java поощряет возврат объектных обёрток или монадических типов (например, Optional<T>) вместо null. Это делает сигнатуру метода более информативной: Optional<Double> явно говорит, что результат может отсутствовать, и заставляет вызывающего обработать оба случая, снижая вероятность NullPointerException.

---

Преобразования типов

В Java допускаются определённые преобразования значений между типами. Эти преобразования делятся на неявные (автоматические, выполняемые компилятором без участия программиста) и явные (требующие прямого указания оператора приведения — cast). Некорректное приведение приводит либо к ошибке компиляции, либо — при выполнении — к исключению.

Расширение (widening conversion)

Расширение — это неявное преобразование значения из типа с меньшим диапазоном представления в тип с большим. Такое преобразование гарантированно безопасно: оно увеличивает разрядную сетку, в которую значение помещается с сохранением семантики.

Цепочка числовых расширений строго фиксирована и следует иерархии:

byte → short → int → long → float → double

Обратите внимание, что char формально не входит в эту цепочку, но может расширяться до int, long, float, double (как беззнаковое 16-битное целое). Например:

char c = 'A';   // 65
int i = c;      // i == 65 — безопасное расширение

Важные нюансы:

• Преобразование long → float технически является расширением по стандарту языка, но не сохраняет точность всех целых значений, так как float имеет лишь 23 бита мантиссы, а long — 64. Целые числа свыше 2²⁴ могут быть округлены при таком преобразовании. Это компромисс стандарта IEEE 754, и разработчик должен быть осведомлён об этом.
• При арифметических операциях с примитивами младше int (byte, short, char) происходит неявное расширение до int перед вычислением. Например:

  byte a = 10, b = 20;
  byte c = (byte)(a + b); // без приведения — ошибка компиляции: a + b имеет тип int

  Это правило называется binary numeric promotion и применяется ко всем бинарным числовым операциям.

Сужение (narrowing conversion)

Сужение — явное преобразование из типа с большим диапазоном в тип с меньшим. Оно потенциально опасно: может привести к потере старших битов, переполнению или искажению значения. Требует оператора приведения вида (TargetType) value.

Примеры:

double d = 123.999;
int i = (int) d;      // i == 123 — дробная часть отброшена (усечение, не округление)

long big = 3_000_000_000L;
int small = (int) big; // small == -1294967296 — переполнение: старшие 32 бита отброшены

int negative = -1;
char ch = (char) negative; // ch == '\uffff' (65535) — интерпретация как беззнакового

Сужение допустимо между:

• числовыми типами (в обратном порядке цепочки расширения);
• int и char (в обе стороны);
• ссылочными типами в пределах иерархии наследования (например, (String) obj), но при несоответствии типов во время выполнения будет выброшено ClassCastException.

Упаковка и распаковка (boxing / unboxing)

Каждому примитивному типу соответствует обёрточный класс (wrapper class) из пакета java.lang:

• byte ↔ Byte
• short ↔ Short
• int ↔ Integer
• long ↔ Long
• float ↔ Float
• double ↔ Double
• boolean ↔ Boolean
• char ↔ Character

Эти классы не являются подтипами Object вместо примитивов — они существуют параллельно и служат для интеграции примитивов в объектную модель: передачи в generic-коллекции, использования в рефлексии, сериализации и т.п.

Начиная с Java 5, компилятор автоматически вставляет вызовы методов valueOf() (для упаковки) и xxxValue() (для распаковки), что называется автоматической упаковкой/распаковкой:

Integer boxed = 42;           // эквивалентно Integer.valueOf(42)
int unboxed = boxed;          // эквивалентно boxed.intValue()

Важнейшие особенности обёрток:

1. Кэширование: для Boolean, Byte, Character (от \u0000 до \u007f), а также Short и Integer в диапазоне от −128 до +127, метод valueOf() возвращает разделяемые экземпляры. Это позволяет безопасно сравнивать такие значения через ==:

   Integer a = 100, b = 100;
   System.out.println(a == b); // true — один и тот же объект из кэша
   Integer c = 200, d = 200;
   System.out.println(c == d); // false — создаются новые объекты

   Однако полагаться на это в коде не рекомендуется — семантически сравнение числовых значений должно выполняться через equals().

2. Null и распаковка: если ссылка на обёртку равна null, попытка распаковки вызовет NullPointerException:

   Integer x = null;
   int y = x; // NPE при распаковке

   Это частая ошибка при работе с базами данных (NULL ↔ null в Integer) или слабо типизированными API.

3. Производительность: упаковка требует аллокации объекта, распаковка — вызова метода. В циклах или горячих участках кода чрезмерное использование boxing/unboxing может существенно снизить производительность. Следует избегать операций вроде:

   List<Integer> numbers = ...;
   long sum = 0;
   for (Integer n : numbers) {
       sum += n; // распаковка на каждой итерации
   }

---

Типы в контексте современных языковых конструкций

Обобщения (generics) и примитивы

Система обобщений в Java реализована через стирание типов (type erasure). На этапе компиляции все параметры типа заменяются их границами (обычно Object), а проверки вставляются в виде приведений. Важное следствие: в качестве аргумента типа нельзя использовать примитив. Следующее не скомпилируется:

List<int> numbers; // ошибка: unexpected type, required: reference, found: int

Вместо этого используются обёртки:

List<Integer> numbers = new ArrayList<>();

Это неизбежно влечёт boxing/unboxing при вставке и извлечении значений. Для высокопроизводительных числовых вычислений существуют сторонние библиотеки (например, Eclipse Collections, FastUtil), предоставляющие специализированные коллекции для примитивов (IntArrayList, LongSet и т.п.).

Тип var и вывод типов

Начиная с Java 10, введён локальный вывод типа через ключевое слово var. Оно позволяет компилятору вывести тип локальной переменной из инициализатора:

var name = "Тимур";          // String
var count = 42;              // int
var list = new ArrayList<String>(); // ArrayList<String>
var result = calculate();    // тип возвращаемого значения calculate()

Важно:

• var не делает Java динамически типизированной. Тип выводится статически и фиксируется на этапе компиляции.
• var допустим только для локальных переменных с инициализатором (не для полей, параметров, возвращаемых типов).
• Инициализатор должен иметь чётко выраженный тип. Например, var x = null; не скомпилируется — null не имеет собственного типа.
• Использование var уместно, когда правая часть делает тип очевидным (как в примерах выше), или когда полное имя типа громоздко (var stream = someObject.getNested().process().stream();). Избегайте var, если это снижает читаемость (var data = fetchData(); — что возвращает fetchData()?).

Записи (record) как типы данных

Начиная с Java 14 (в статусе preview), а с Java 16 — как стабильная функция, введены записи (record). Это компактный синтаксис для объявления классов-носителей данных, у которых состояние полностью определяется фиксированным набором значений (компонентов):

public record Person(String name, int age) {}

Компилятор автоматически генерирует:

• приватные final поля для каждого компонента;
• публичный конструктор с параметрами в порядке объявления;
• геттеры с именами, совпадающими с именами компонентов (name(), age());
• equals(), hashCode() и toString() на основе всех компонентов.

Записи неизменяемы по замыслу: компоненты — final, а методы изменения не генерируются. Это делает их идеальными для представления значений (value types), а не сущностей с идентичностью. Записи наследуются от java.lang.Record, который, в свою очередь, наследуется от Object.

---

Практические рекомендации по выбору типа

Для целочисленных значений

• Почти всегда используйте int, если только диапазон явно не требует long. Это стандарт, который ожидает весь экосистемный код (библиотеки, фреймворки, API).
• Используйте long для:
  • временных меток в миллисекундах (System.currentTimeMillis());
  • идентификаторов в распределённых системах (Snowflake ID);
  • счётчиков, которые теоретически могут превысить 2 млрд (например, число событий в логе за год).
• Избегайте byte и short, кроме специфических случаев:
  • взаимодействие с протоколами или форматами, где размер поля строго фиксирован (например, заголовки сетевых пакетов);
  • обработка бинарных данных (изображения, аудио, файлы);
  • критичные по памяти структуры, содержащие миллионы элементов (но сначала — профилирование!).

Для вещественных чисел

• Используйте double для всех научных, инженерных и аналитических вычислений, где важна скорость, а погрешность в пределах 15 знаков допустима.
• Никогда не используйте float или double для денег. Вместо этого:
  • для простых случаев — long с фиксированным масштабом (например, копейки);
  • для сложных — java.math.BigDecimal с явным указанием стратегии округления (RoundingMode.HALF_UP и др.).

Для логических значений

• Используйте boolean, а не Boolean, если значение не может быть «неизвестным». Например, isActive, isVerified — boolean.
• Используйте Boolean, если трёхзначная логика нужна семантически: true / false / не применимо или данные отсутствуют. Типичный пример — опциональные флаги в DTO, пришедшие из внешнего API.

Для текста

• Используйте String для неизменяемых значений. Он оптимизирован, безопасен и эффективен благодаря пулу.
• Используйте StringBuilder для конкатенации в цикле или при сборке сложных строк по частям.
• Избегайте StringBuffer, если нет требования потокобезопасности — он избыточен в большинстве современных приложений (stateless-сервисы, локальные переменные).

Для коллекций данных

• Предпочитайте интерфейсы (List, Set, Map) конкретным реализациям в сигнатурах методов и полях. Это повышает гибкость и тестируемость.
• Используйте массивы только если:
  • требуется максимальная производительность доступа (например, в числовой обработке);
  • интерфейс взаимодействия с нативным кодом (JNI) или старыми API фиксирован;
  • размер строго известен и неизменен.
• В остальных случаях — коллекции (ArrayList, HashMap и др.).

В API и сериализации

• Типы полей в DTO и моделях должны быть совместимы с сериализаторами (Jackson, Gson). Например:
  • избегайте Object — затрудняет десериализацию;
  • будьте осторожны с Optional в полях — многие сериализаторы не поддерживают их «из коробки»;
  • предпочитайте List вместо массивов — лучше поддержка, больше методов.
• Для внешних контрактов (REST, gRPC) явно документируйте типы и диапазоны — не полагайтесь на «умолчания» языка.

---